home *** CD-ROM | disk | FTP | other *** search
/ Echoes of Ireland / Echoes of Ireland.iso / IRISH_ENGINE / action_script / loadXML2.as < prev   
Text File  |  2004-06-10  |  9KB  |  310 lines
  1. /*-----------------------------------------------------------------*\
  2. |    File:            loadXML.as
  3. |    Language:        ActionScript
  4. |    Purpose:        Define generic functions that can be used by
  5. |                    any Flash 5 application to receive
  6. |                    JavaScript Objects from a server via XML.
  7. |
  8. |                    This makes it so that the Flash developer
  9. |                    doesn't have to hand-code all of the logic
  10. |                    for loading and stepping thorugh complex data
  11. |                    structures via XML.  ECMAScript Objects
  12. |                    are much simpler to deal with.
  13. |
  14. |    Dependancies:    none
  15. |    By:                Phil Scott
  16. |    Developed:        April 2001
  17. |
  18. |    Class:            LoadXML
  19. |
  20. |    Constructor:
  21. |        var myXML = new LoadXML();
  22. |                (or)
  23. |        var myXML = new LoadXML(myObject);
  24. |
  25. |    Public Methods:
  26. |        .getFrom( strURL )
  27. |
  28. |    Public Properties:
  29. |        .errorMsg            // string value, containing any error messages after a call
  30. |                            //        to any one of the class methods.  If everything was
  31. |                            //        processed successfully, this property should have a
  32. |                            //        value of "" (empty string).
  33. |        .transferComplete    // boolean (true or false) value, set after a call to the
  34. |                            //     .sentTo() or .getFrom() method.
  35. |        .onLoad                // function reference, pointing to a user-defined function
  36. |                            //         that gets called by LoadXML whenever Flash
  37. |                            //        finishes loading the XML data.
  38. |
  39. |    Private Properties:
  40. |        .object
  41. |        .xmlString
  42. |        .xmlDoc
  43. |
  44. |    Private Functions:
  45. |        XMLDocToObject(oXML)
  46. |        buildObject(obj, eItem)
  47. |
  48. |    Copyright Juxt Interactive, 2001.  All Rights Reserved.
  49. \*-----------------------------------------------------------------*/
  50.  
  51.  
  52. var XML_NODE_TYPE_TEXT = 3;
  53. var XML_NODE_TYPE_ELEMENT = 1;
  54.  
  55. //-------------------------------------------------------------------
  56. // Purpose: given an XML document converts the contents into
  57. //            a JavaScript object.
  58. //-------------------------------------------------------------------
  59. function XMLDocToObject(oXML) {
  60.     trace("XMLDocToObject called");
  61.     var obj = [];
  62.  
  63.     if (oXML == null) {
  64.         return obj;
  65.     }
  66.  
  67.     //--- Step past the root element to the first ARRAY node ---
  68.     var eRoot = oXML.firstChild;
  69.     if (eRoot != null) {
  70.  
  71.         //--- Start with the first node ---
  72.         obj = buildObject(obj, eRoot);
  73.     }
  74.  
  75. //dumpObject(obj, 0, 'XMLDocToObject: obj');
  76.  
  77.     return obj;
  78. }
  79.  
  80. //-------------------------------------------------------------------
  81. // Purpose: Called by XMLDocToObject() function, to recursively build
  82. //            the object from the XML document.
  83. //-------------------------------------------------------------------
  84. function buildObject(obj, eItem) {
  85.  
  86.     var idx, eChild;
  87.     var oTarget;
  88.  
  89.  
  90.     //--- Loop through the sibling elements in this level of the XML ---
  91.     while (eItem != null) {
  92.            idx = eItem.nodeName;
  93.  
  94.         if (eItem.nodeType == XML_NODE_TYPE_ELEMENT) {
  95.  
  96.             //
  97.             //--- Recursively process any other child nodes ---
  98.             oTarget = buildObject( {}, eItem.firstChild);
  99.  
  100.  
  101.             //
  102.             //--- Process any XML node attributes ---
  103.             for (var attrib in eItem.attributes) {
  104.                 oTarget['_attrib_' + attrib] = eItem.attributes[attrib]; // <----------------------------------
  105.             }
  106.  
  107.             //
  108.             //--- Check the first child, and see if it's a simple text node ---
  109.             if (eItem.nodeValue != null ) {
  110.                 //--- Save the value from the TEXT element into the object ---
  111.                 oTarget._value = eItem.nodeValue;
  112.             } else {
  113.                 eChild = eItem.firstChild;
  114.                 if (eChild != null) {
  115.                     if (eChild.nodeType == XML_NODE_TYPE_TEXT) {
  116.                         if (eChild.nodeValue != null) {
  117.                             //--- Save the value from the TEXT element into the object ---
  118.                             oTarget._value = eChild.nodeValue;
  119.                         }
  120.                     }
  121.                 }
  122.             }
  123.  
  124.             //
  125.             //--- If there are duplicate nodenames, convert them to an array ---
  126.             //if (obj[idx] != null || eChild.parentNode.nodeName == "EPSSPOA") {
  127.             if (obj[idx] != null ) {
  128.  
  129.                 if (obj[idx]._type != 'array') {
  130.                 //    oTarget = new Array();
  131.                 //    oTarget[0] = obj[idx];
  132.                 //    obj[idx] = oTarget;
  133.  
  134.                     obj[idx] = [ obj[idx] ];
  135.                     obj[idx]._type = 'array';
  136.                     obj[idx][1] = oTarget;
  137.                 } else {
  138.                     obj[idx][ obj[idx].length ] = oTarget;
  139.                 }
  140.             } else {
  141.                 obj[idx] = oTarget;
  142.             }
  143.  
  144.         }    //*** END OF: if (eItem.nodeType == XML_NODE_TYPE_ELEMENT) ***
  145.  
  146.  
  147.  
  148.         //-- Get the next sibling node in this level of the XML ---
  149.         eItem = eItem.nextSibling;
  150.  
  151.     }    //*** END OF: while(eItem != null) ***
  152.  
  153.     return obj;
  154. }
  155.  
  156. //-------------------------------------------------------------------
  157. // Purpose: Class constructor for LoadXML Class.
  158. //-------------------------------------------------------------------
  159. function LoadXML (strURL) {
  160.  
  161.  
  162.     //this.onLoad = fpHandlerFunction;
  163.  
  164.     this.xmlString = "";
  165.     this.errorMsg = "";
  166.     this.xmlDoc = new XML();
  167.  
  168.     this.getFrom(strURL)
  169.  
  170.     this.onLoad = function (){
  171.     trace("on data loaded called");
  172.     if ("" == this.errorMsg) {
  173.         //oXMLLoader.xmlObject = new Object();
  174.         this.xmlObject = this.object;
  175.         //
  176.         //
  177.         // --- NOTE: if you want to see a trace of the object after
  178.         // --- it has been constructed from the XML, then
  179.         // --- unremark the following line of code...
  180.         //
  181.         // dumpObject(oXMLLoader.object, 0, 'oXMLLoader.object');
  182.         //
  183.     } else {
  184.         trace ('error loading data: '+this.errorMsg);
  185.     }
  186.     _level0.dataLoaded = true;
  187.     }
  188.  
  189.     return this;
  190. }
  191.  
  192. //-------------------------------------------------------------------
  193. // Purpose: Starts the process of loading an object (via XML) from
  194. //            a URL.
  195. // Notes: The object does not become available immediately upon return
  196. //            of this function.  The transfer starts running in the
  197. //            background.  When the object has been loaded, the
  198. //            .transferComplete property of the LoadXML will be
  199. //            true.
  200. //            example:
  201. //                if(myAryTrans.transferComplete == true) {
  202. //                    gotoAndPlay('continue');
  203. //                }
  204. //-------------------------------------------------------------------
  205. LoadXML.prototype.getFrom = function( strURL ) {
  206.  
  207.     //--- Make sure the caller passed a URL ---
  208.     if (null == strURL) {
  209.         this.errorMsg = "object.getFrom() requires a 'strURL' parameter.";
  210.         return;
  211.     }
  212.  
  213.     if (null == this.xmlDoc) {
  214.         this.xmlDoc = new XML();
  215.     }
  216.  
  217.  
  218.     this.errorMsg = "";
  219.  
  220.     //--- Set up an event handler for the response document ---
  221.     this.xmlDoc.onLoad = onXMLLoaded;
  222.     this.xmlDoc.refToLoadXMLObj = this;
  223.  
  224.     //--- Initialize the .transferComplete property so the loader can check when we're done ---
  225.     this.transferComplete = false;
  226.  
  227.     //--- Start the asynchronous data transfer with the server ---
  228.     this.xmlDoc.load(strURL);
  229.  
  230.     return;
  231. }
  232.  
  233. //--- Attach this function definition to the Class, as a method ---
  234. //LoadXML.prototype.getFrom = _getFrom;
  235.  
  236.  
  237. //-------------------------------------------------------------------
  238. // Purpose:  handle onLoad event from XML.load() function.
  239. //-------------------------------------------------------------------
  240. function onXMLLoaded() {
  241.     trace("onXMLLoaded called");
  242.     var oXML = this;
  243.  
  244.     //--- extract a pointer to the original LoadXML object from the XML object ---
  245.     var oLoadXML = this.refToLoadXMLObj;
  246.  
  247.     //--- Convert the XML document to an object ----
  248.     oLoadXML.object = XMLDocToObject( oXML );
  249.  
  250.     //--- Set a flag to let outsiders know we're done! ---
  251.     oLoadXML.transferComplete = true;
  252.  
  253.     //--- If a handler function has been assigned, call it now ---
  254.     if (typeof(oLoadXML.onLoad) == 'function') {
  255.         oLoadXML.onLoad( oLoadXML );
  256.     }
  257.  
  258. }
  259.  
  260. //----------------------------------------------------------------------------
  261. // --- debugging function....
  262. function dumpObject( obj, nLevels, sName ) {
  263.     var idx, sPre = '';
  264.     if (nLevels == null) {
  265.         nLevels = 0;
  266.     }
  267.     for (idx=1; idx<=nLevels; idx++) {
  268.         sPre += '\t';
  269.     }
  270.     trace(sPre + sName + '{');
  271.     nLevels++;
  272.     for (idx in obj) {
  273.         if (typeof(obj[idx]) == 'object') {
  274.             dumpObject( obj[idx], nLevels, idx );
  275.         } else {
  276.             trace(sPre + idx + '="' + obj[idx] + '"');
  277.         }
  278.     }
  279.  
  280.     trace(sPre + '}');
  281.  
  282. }
  283.  
  284.  
  285. //
  286. // ----------------------------------------------------------------------------
  287. // Function:  onDataLoaded()
  288. // Purpose:   Gets called by the LoadXML object, when the XML data has
  289. // finished loading
  290. // ----------------------------------------------------------------------------
  291. function onDataLoaded (oXMLLoader) {
  292.     if ("" == oXMLLoader.errorMsg) {
  293.         xmlObject = oXMLLoader.object;
  294.         //
  295.         //
  296.         // --- NOTE: if you want to see a trace of the object after
  297.         // --- it has been constructed from the XML, then
  298.         // --- unremark the following line of code...
  299.         //
  300.          //dumpObject(oXMLLoader.object, 0, 'oXMLLoader.object');
  301.         //
  302.     } else {
  303.         trace ('error loading data: '+oXMLLoader.errorMsg);
  304.     }
  305.     dataLoaded = true;
  306. }
  307.  
  308.  
  309.  
  310.